package com.bckj.fastboot.core.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 对象序列化工具类
 */
public class SerializeUtils {

    /**
     * 序列化对象为字节数组
     * @param object 可序列化的对象
     * @return 序列化后的字节数组
     * @throws IOException 如果序列化失败
     */
    public static byte[] serialize(Serializable object) throws IOException {
        if (object == null) {
            return null;
        }

        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(object);
            oos.flush();
            return baos.toByteArray();
        }
    }

    /**
     * 反序列化字节数组为对象
     * @param bytes 序列化后的字节数组
     * @return 反序列化后的对象
     * @throws IOException 如果反序列化失败
     * @throws ClassNotFoundException 如果类找不到
     */
    @SuppressWarnings("unchecked")
    public static <T> T deserialize(byte[] bytes) throws IOException, ClassNotFoundException {
        if (bytes == null || bytes.length == 0) {
            return null;
        }

        try (ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
             ObjectInputStream ois = new ObjectInputStream(bais)) {
            return (T) ois.readObject();
        }
    }

    /**
     * 安全的序列化方法（不抛出受检异常）
     * @param object 可序列化的对象
     * @return 序列化后的字节数组，失败返回null
     */
    public static byte[] serializeSafe(Serializable object) {
        try {
            return serialize(object);
        } catch (IOException e) {
            return null;
        }
    }

    /**
     * 安全的反序列化方法（不抛出受检异常）
     * @param bytes 序列化后的字节数组
     * @return 反序列化后的对象，失败返回null
     */
    public static <T> T deserializeSafe(byte[] bytes) {
        try {
            return deserialize(bytes);
        } catch (IOException | ClassNotFoundException e) {
            return null;
        }
    }
}